home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / µSim 1.0.5 / source / DoMenu.c < prev    next >
Encoding:
Text File  |  1995-12-06  |  13.2 KB  |  559 lines  |  [TEXT/CWIE]

  1. /*
  2. Copyright © 1993,1994,1995 Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware:
  5. you may copy, exchange, modify this code.
  6. You may include this code in any kind of application: freeware,
  7. shareware, or commercial, provided that full credits are given.
  8. You may not sell or distribute this code for profit.
  9. */
  10.  
  11. //#pragma load "MacDump"
  12.  
  13. #include    "UtilsSys7.h"
  14. #include    "Internet.h"
  15. #include    "FabLibResIDs.h"
  16.  
  17. #include    "AEHandlers.h"
  18. #include    "Globals.h"
  19. #include    "Animation.h"
  20. #include    "Assembler.h"
  21. #include    "ControlStore.h"
  22. #include    "Disasm.h"
  23. #include    "DoMenu.h"
  24. #include    "Dump.h"
  25. #include    "Input.h"
  26. #include    "Main.h"
  27. #include    "Microprogram_Ed.h"
  28. #include    "myMemory.h"
  29. #include    "Preferences.h"
  30. #include    "Registers.h"
  31. #include    "Simulator.h"
  32. #include    "SimUtils.h"
  33.  
  34. #if defined(FabSystem7orlater)
  35.  
  36. //#pragma segment Main
  37.  
  38. short lastCommand = kST_STOPPED;
  39.  
  40. static void DoMenuApple(short theItem);
  41. static void DoMenuEdit(short theItem);
  42. static void DoMenuMemory(short theItem);
  43. static void DoMenuRegs(short theItem);
  44. static void DoMenuHDisasm(short theItem);
  45. static void DoMenuHDump(short theItem);
  46. static void DoMenuControl(short theItem);
  47. static void CompletePreviousInstruction(void);
  48. static void DoMenuAssembler(short theItem);
  49.  
  50. void DoMenuApple(short theItem)
  51. {
  52. Str255    DAName;
  53.  
  54. if (theItem == kMItem_About__Simulato) {
  55. //    myAbout(DoIdle, nil, DoUpdate, DoActivate);
  56.     myMovableModalAbout(gPrefs.remembWind ? &gPrefs.aboutTL : nil,
  57.         gPrefs.remembWind ? &gPrefs.creditsTL : nil,
  58.         AdjustMenus,
  59.         Handle_My_Menu,
  60.         DomyKeyEvent,
  61.         DoUpdate,
  62.         DoActivate,
  63.         DoHighLevelEvent,
  64.         DoOSEvent,
  65.         DoIdle,
  66.         gSleep
  67.         );
  68.     UnloadSeg(myAbout);
  69.     }
  70. else {
  71. //    AdjustMenus(nil);
  72.     GetMenuItemText(gMenu_Apple, theItem, DAName);
  73.     (void)OpenDeskAcc(DAName);
  74.     AdjustMenus(nil);
  75.     }
  76. }
  77.  
  78. void DoMenuFile(short theItem)
  79. {
  80. register OSErr    err;
  81.  
  82. switch (theItem) {
  83.     case kMItem_New:
  84.         if (ReadyToTerminate()) {
  85.             DoNew();
  86.             UnloadSeg(DoNew);
  87.             DoMenuWindows(kMItem_Microprogram);
  88.             }
  89.         break;
  90.     case kMItem_Open_Control_St: {
  91.         StandardFileReply    mySFR;
  92.         SFTypeList    myTypeList;
  93.  
  94.         if (ReadyToTerminate()) {
  95.             myTypeList[0] = kFTY_CSTORE;
  96.             myTypeList[1] = kFTY_CSTOREPAD;
  97.             StandardGetFile(0L, 2, myTypeList, &mySFR);
  98.             if (mySFR.sfGood) {
  99.                 err = myOpenCSFile(&mySFR.sfFile, mySFR.sfScript,
  100.                                         (mySFR.sfFlags & kfIsStationery) != 0);
  101.                 UnloadSeg(myOpenCSFile);
  102.                 if (err)
  103.                     ErrorAlert(err);
  104.                 }
  105.             }
  106.         }
  107.         break;
  108.     case kMItem_Close:
  109.         (void)ReadyToTerminate();
  110.         break;
  111.     case kMItem_Save_Control_St:
  112.         err = mySaveCSFile(kGOT_SAVE);
  113.         UnloadSeg(mySaveCSFile);
  114.         if (err)
  115.             if (err != 1)
  116.                 ErrorAlert(err);
  117.         break;
  118.     case kMItem_Save_Control_St2:
  119.         err = mySaveCSFile(kGOT_SAVEAS);
  120.         UnloadSeg(mySaveCSFile);
  121.         if (err)
  122.             if (err != 1)
  123.                 ErrorAlert(err);
  124.         break;
  125.     case kMItem_Save_CS_Stationery:
  126.         err = mySaveCSFile(kGOT_SAVESTATIONERY);
  127.         UnloadSeg(mySaveCSFile);
  128.         if (err)
  129.             if (err != 1)
  130.                 ErrorAlert(err);
  131.         break;
  132.     case kMItem_Revert_to_Saved:
  133.         if (CautionAlert_UPP(kALRT_REVERT, myStdFilterProc) == ok) {
  134.             err = RevertFile();
  135.             UnloadSeg(RevertFile);
  136.             if (err)
  137.                 ErrorAlert(err);
  138.             }
  139.         break;
  140. /*    case kMItem_Page_Setup:
  141.         PageSetup();
  142.         UnloadSeg(PageSetup);
  143.         break;
  144.     case kMItem_Print:
  145.         Print_The_Data();
  146.         UnloadSeg(Print_The_Data);
  147.         break;*/
  148.     case kMItem_Prefs:
  149.         Preferences();
  150.         UnloadSeg(Preferences);
  151.         break;
  152.     case kMItem_Quit:
  153.         if (ReadyToTerminate())
  154.             gDoneFlag = true;
  155.         break;
  156.     }
  157. }
  158.  
  159. void DoMenuEdit(short theItem)
  160. {
  161. register Ptr    scPtr;
  162. register union u_mir *scanPtr;
  163. register union u_mir    tmpmir;
  164. register OSErr    err;
  165. register Byte    val;
  166.  
  167. if (SystemEdit(theItem - 1) == false) {
  168.     switch (theItem) {
  169. /* not implemented yet */
  170. //        case kMItem_Undo:
  171. //            break;
  172.         case kMItem_Cut:
  173.             if (gTheInput) {
  174.                 TECut(gTheInput);
  175.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  176.                     Microprog_TextWasModified();
  177.                 else if (gWPtr_IO == FrontWindow())
  178.                     AdjustScrollbars(gWPtr_IO, false);
  179.                 if ((err = ZeroScrap()) == noErr)
  180.                     err = TEToScrap();
  181.                 if (err)
  182.                     ErrorAlert(err);
  183.                 }
  184.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  185.                         (keyDownDest == kKEY_LIST))
  186.                 if (err = SendClipMsg(kCLIPMSG_CUT))
  187.                     ErrorAlert(err);
  188.             break;
  189.  
  190.         case kMItem_Copy:
  191.             if (gTheInput) {
  192.                 TECopy(gTheInput);
  193.                 if ((err = ZeroScrap()) == noErr)
  194.                     err = TEToScrap();
  195.                 if (err)
  196.                     ErrorAlert(err);
  197.                 }
  198.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  199.                         (keyDownDest == kKEY_LIST))
  200.                 if (err = SendClipMsg(kCLIPMSG_COPY))
  201.                     ErrorAlert(err);
  202.             break;
  203.  
  204.         case kMItem_Paste:
  205.             if (gTheInput) {
  206.                 TEPaste(gTheInput);
  207.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  208.                     Microprog_TextWasModified();
  209.                 else if (gWPtr_IO == FrontWindow())
  210.                     AdjustScrollbars(gWPtr_IO, false);
  211.                 }
  212.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  213.                         (keyDownDest == kKEY_LIST))
  214.                 if (err = SendClipMsg(kCLIPMSG_PASTE))
  215.                     ErrorAlert(err);
  216.             break;
  217.  
  218.         case kMItem_Clear:
  219.             if (gTheInput) {
  220.                 TEDelete(gTheInput);
  221.                 if (gWPtr_Microprogram_Ed == FrontWindow())
  222.                     Microprog_TextWasModified();
  223.                 else if (gWPtr_IO == FrontWindow())
  224.                     AdjustScrollbars(gWPtr_IO, false);
  225.                 }
  226.             else if ((gWPtr_Microprogram_Ed == FrontWindow()) &&
  227.                         (keyDownDest == kKEY_LIST))
  228.                 if (err = SendClipMsg(kCLIPMSG_CLEAR))
  229.                     ErrorAlert(err);
  230.             break;
  231.         case kMItem_Select_All:
  232.             if (gTheInput)
  233.                 TESetSelect(0, SHRT_MAX, gTheInput);
  234.             break;
  235.         case kMItem_Insert:
  236. //            LSetDrawingMode(false, Lists[kL_COMMENTS]);
  237.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  238.                 gCsMemory + theSelection[kL_COMMENTS] + 1,
  239.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS]));
  240.             gCsMemory[theSelection[kL_COMMENTS]].cstore = 0L;
  241.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  242.                     tmpmir = *scanPtr++)
  243.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  244.                     if (tmpmir.bits.addr != 0x7F) { /* WARNING: non-portable form */
  245.                         tmpmir.bits.addr++;
  246.                         *(scanPtr - 1) = tmpmir;
  247.                         }
  248.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  249.                 if (val >= theSelection[kL_COMMENTS]) {
  250.                     val++;
  251.                     *(scPtr - 1) = val;
  252.                     }
  253.             LDelRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  254.             LAddRow(1, theSelection[kL_COMMENTS]++, Lists[kL_COMMENTS]);
  255.             DocumentIsDirty(true);
  256. //            LSetDrawingMode(true, Lists[kL_COMMENTS]);
  257.             LAutoScroll(Lists[kL_COMMENTS]);
  258.             break;
  259.         case kMItem_Delete:
  260. //            LSetDrawingMode(false, Lists[kL_COMMENTS]);
  261.             for (scanPtr = gCsMemory; scanPtr < (gCsMemory + maxLLine[kL_COMMENTS]);
  262.                     tmpmir = *scanPtr++)
  263.                 if (tmpmir.bits.addr >= theSelection[kL_COMMENTS])
  264.                     if (tmpmir.bits.addr) {
  265.                         tmpmir.bits.addr--;
  266.                         *(scanPtr - 1) = tmpmir;
  267.                         }
  268.             for (scPtr = gAssMemory; scPtr < (gAssMemory + kSIZE_ASSMEM); val = *scPtr++)
  269.                 if (val > theSelection[kL_COMMENTS]) {
  270.                     val--;
  271.                     *(scPtr - 1) = val;
  272.                     }
  273.             SelectLLine(kL_COMMENTS, theSelection[kL_COMMENTS] + 1);
  274.             BlockMoveData(gCsMemory + theSelection[kL_COMMENTS],
  275.                 gCsMemory + theSelection[kL_COMMENTS] - 1,
  276.                 sizeof(union u_mir)*(maxLLine[kL_COMMENTS] - theSelection[kL_COMMENTS] + 1));
  277.             gCsMemory[maxLLine[kL_COMMENTS]].cstore = 0L;
  278.             LDelRow(1, --theSelection[kL_COMMENTS], Lists[kL_COMMENTS]);
  279.             LAddRow(1, maxLLine[kL_COMMENTS], Lists[kL_COMMENTS]);
  280.             DocumentIsDirty(true);
  281. //            LSetDrawingMode(true, Lists[kL_COMMENTS]);
  282.             LAutoScroll(Lists[kL_COMMENTS]);
  283.             break;
  284.         case kMItem_CopyBugReport:
  285.             CopyBugReportForm(nil);
  286.             UnloadSeg(CopyBugReportForm);
  287.             break;
  288.         case kMItem_CopyEmailAddr:
  289.             CopyEMailAddrToClip();
  290.             break;
  291. //        case kMItem_CopyWWWURL:
  292. //            CopyWWWURLToClip();
  293. //            break;
  294.         case kMItem_SendEmail:
  295.             InternetLaunch(gICinst, &gICerr, myStdFilterProcNoCancel, myIdleFunct, kSTR_MAILTOURL);
  296.             break;
  297. //        case kMItem_ShowWWWPage:
  298. //            InternetLaunch(gICinst, &gICerr, myStdFilterProcNoCancel, myIdleFunct, kSTR_WWWURL);
  299. //            break;
  300.         }
  301.     }
  302. }
  303.  
  304. void DoMenuWindows(short theItem)
  305. {
  306. register WindowPtr    wind;
  307.  
  308. switch (theItem) {
  309.     case kMItem_Animation:
  310.         wind = gWPtr_Animation;
  311.         break;
  312.     case kMItem_Registers:
  313.         wind = gWPtr_Registers;
  314.         break;
  315.     case kMItem_IO:
  316.         wind = gWPtr_IO;
  317.         break;
  318.     case kMItem_Microprogram:
  319.         PrepareOpenMicroprogram();
  320.         wind = gWPtr_Microprogram_Ed;
  321.         break;
  322.     case kMItem_Disasm:
  323.         wind = gWPtr_Disasm;
  324.         break;
  325.     case kMItem_Dump:
  326.         wind = gWPtr_Dump;
  327.         break;
  328.     }
  329. ShowWindowAndCheckMenu(wind, theItem);
  330. SelectWindow(wind);
  331. }
  332.  
  333. void ShowWindowAndCheckMenu(WindowPtr w, short theMenuItem)
  334. {
  335. if (((WindowPeek)w)->visible == false) {
  336.     CheckItem(gMenu_Windows, theMenuItem, true);
  337.     SetPort(w);
  338.     ShowWindow(w);
  339.     }
  340. }
  341.  
  342. void DoMenuMemory(short theItem)
  343. {
  344. register OSErr    err;
  345.  
  346. switch (theItem) {
  347.     case kMItem_Open: {
  348.         StandardFileReply    mySFR;
  349.         SFTypeList    myTypeList;
  350.  
  351.         myTypeList[0] = kFTY_RAM;
  352.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  353.         if (mySFR.sfGood) {
  354.             if (err = myOpenFile(&mySFR.sfFile, gMMemory, kSIZE_RAM))
  355.                 ErrorAlert(err);
  356.             UnloadSeg(myOpenFile);
  357.             }
  358.         }
  359.         break;
  360.     case kMItem_Save_As:
  361.         if (err = mySaveFile(gMMemory, kSIZE_RAM, kFTY_RAM, kSTR_RAMPROMPT, kSTR_RAMDEFNAME))
  362.             ErrorAlert(err);
  363.         UnloadSeg(mySaveFile);
  364.         break;
  365.     }
  366. }
  367.  
  368. void    DoMenuRegs(short theItem)
  369. {
  370. register OSErr    err;
  371.  
  372. switch (theItem) {
  373.     case kMItem_Open: {
  374.         StandardFileReply    mySFR;
  375.         SFTypeList    myTypeList;
  376.  
  377.         myTypeList[0] = kFTY_REG;
  378.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  379.         if (mySFR.sfGood) {
  380.             if (err = OpenProcessorState(&mySFR.sfFile))
  381.                 ErrorAlert(err);
  382.             UnloadSeg(OpenProcessorState);
  383.             }
  384.         }
  385.         break;
  386.     case kMItem_Save_As:
  387.         if (err = SaveProcessorState())
  388.             ErrorAlert(err);
  389.         UnloadSeg(SaveProcessorState);
  390.         break;
  391.     }
  392. }
  393.  
  394. static void    DoMenuHDisasm(short theItem)
  395. {
  396. SetControlValue(disasmVScroll, (unsigned short)gRegs[theItem - 1] >> 1);
  397. InvalDisasm();
  398. }
  399.  
  400. static void    DoMenuHDump(short theItem)
  401. {
  402. SetControlValue(dumpVScroll, (unsigned short)gRegs[theItem - 1] >> 3);
  403. InvalDump();
  404. }
  405.  
  406. /* da schiaffare dentro la routine successiva */
  407. const short toDeact[] = {    kP_MPC2INC, kP_INCR, kP_MPC2CST, kP_CST2MIR,
  408.                             kP_REG2LTCH1, kP_REG2LTCH2, kP_ALATCH, kP_BLATCH,
  409.                             kP_AMUX2ALU, kP_BLTCH2ALU, kP_ALU, kP_ALU2SH,
  410.                             kP_SHIFTER, kP_SH2REGS1, kP_SH2REGS2, kP_SH2REGS3,
  411.                             kP_MAR, kP_BLTCH2MAR1, kP_BLTCH2MAR2,
  412.                             kP_MBR, kP_SH2MBR1, kP_SH2MBR2, kP_MAP, kP_MAPREGS,
  413.                             kP_ALTCH2AMUX, kP_AMUX, kP_MBR2AMUX,
  414.                             kP_INC2MMUX1, kP_INC2MMUX2, kP_MMUX, kP_MPC,
  415.                             kC_ADDR1, kC_ADDR2, kP_MMUX2MPC, 0 };
  416.  
  417. void DoMenuControl(short theItem)
  418. {
  419. short lastCommand = kST_STOPPED;
  420. register OSErr    err;
  421.  
  422. switch (theItem) {
  423.     case kMItem_Go:
  424.         gRstatus = kST_GOING;
  425.         CompletePreviousInstruction();
  426.         lastCommand = kST_GOING;
  427.         break;
  428.     case kMItem_Stop:
  429.         StopIt();
  430.         lastCommand = kST_STOPPED;
  431.         break;
  432.     case kMItem_StepSub:
  433.         gRstatus = kST_STEPSUBCYC;
  434.         if (lastCommand != kST_STEPSUBCYC) {
  435.             DeactivateObjs(toDeact);
  436.             lastCommand = kST_STEPSUBCYC;
  437.             }
  438.         break;
  439.     case kMItem_StepMicro:
  440.         gRstatus = kST_STEPMPROG;
  441.         lastCommand = kST_STEPMPROG;
  442.         break;
  443.     case kMItem_StepInstr:
  444.         gRstatus = kST_STEPASM;
  445.         CompletePreviousInstruction();
  446.         lastCommand = kST_STEPASM;
  447.         break;
  448.     case kMItem_ResetMem:
  449.         if ((err = CautionAlert_UPP(kALRT_RESETMEM, myStdFilterProc)) == ok) {
  450.             MyZeroBuffer((long *)gMMemory, numOfLongs(kSIZE_RAM));
  451.             ResetMemory();
  452.             InvalDump();
  453.             InvalDisasm();
  454.             }
  455.         break;
  456.     case kMItem_ResetRegs:
  457.         if ((err = CautionAlert_UPP(kALRT_RESETREGS, myStdFilterProc)) == ok) {
  458.             ResetRegisters();
  459.             UnloadSeg(ResetRegisters);
  460.             ChangedRegister(kREG_PC);
  461.             ChangedRegister(kREG_SP);
  462.             ChangedBox(kP_MPC - kFIRST_PICT);
  463.             }
  464.         break;
  465.     case kMItem_SelectCurMPC:
  466.         SelectLLine(kL_COMMENTS, gParts[kP_MPC - kFIRST_PICT]);
  467.         DoMenuWindows(kMItem_Microprogram);
  468.         break;
  469.     }
  470. }
  471.  
  472. /* CompletePreviousInstruction: keeps in sync the processor when
  473. alternating different step modes with continuous execution */
  474.  
  475. static void CompletePreviousInstruction(void)
  476. {
  477. while (gSubclk) {
  478.     ExecuteInstructions(gSubclk++);
  479.     gSubclk &= 3;
  480.     }
  481. }
  482.  
  483. void DoMenuAssembler(short theItem)
  484. {
  485. register OSErr    err;
  486.  
  487. switch (theItem) {
  488.     case kMItem_Assemble_file: {
  489.         StandardFileReply    mySFR;
  490.         SFTypeList    myTypeList;
  491.  
  492.         myTypeList[0] = 'TEXT';
  493.         StandardGetFile(0L, 1, myTypeList, &mySFR);
  494.         if (mySFR.sfGood) {
  495.             if (err = myAsmFile(&mySFR.sfFile))
  496.                 ErrorAlert(err);
  497.             UnloadSeg(myAsmFile);
  498.             }
  499.         }
  500.         break;
  501.     case kMItem_AsmPrefs:
  502.         DoAsmPrefsDialog();
  503.         UnloadSeg(DoAsmPrefsDialog);
  504.         break;
  505.     }
  506. }
  507.  
  508. void Handle_My_Menu(long myMenu)
  509. {
  510. register short    theMenu, theItem;
  511.  
  512. theMenu = HiWrd(myMenu);
  513. if (theMenu) {
  514.     theItem = LoWrd(myMenu);
  515.     switch (theMenu) {
  516.         case kRes_Menu_HMemory:
  517.             DoMenuMemory(theItem);
  518.             break;
  519.         case kRes_Menu_HRegs:
  520.             DoMenuRegs(theItem);
  521.             break;
  522.         case kRes_Menu_HDisasm:
  523.             DoMenuHDisasm(theItem);
  524.             break;
  525.         case kRes_Menu_HDump:
  526.             DoMenuHDump(theItem);
  527.             break;
  528.         case kMENU_HCopyWebLocation:
  529.             CopyWWWURLToClip(theItem);
  530.             break;
  531.         case kMENU_HVisitWebLocation:
  532.             InternetLaunch(gICinst, &gICerr, myStdFilterProcNoCancel, myIdleFunct, kSTR_WWWURLITA - 1 + theItem);
  533.             break;
  534.         case kRes_Menu_Apple:
  535.             DoMenuApple(theItem);
  536.             break;
  537.         case kRes_Menu_File:
  538.             DoMenuFile(theItem);
  539.             break;
  540.         case kRes_Menu_Edit:
  541.             DoMenuEdit(theItem);
  542.             break;
  543.         case kRes_Menu_Windows:
  544.             DoMenuWindows(theItem);
  545.             break;
  546.         case kRes_Menu_Control:
  547.             DoMenuControl(theItem);
  548.             break;
  549.         case kRes_Menu_Assembler:
  550.             DoMenuAssembler(theItem);
  551.             break;
  552.         }
  553.     }
  554. HiliteMenu(0);
  555. }
  556.  
  557. #endif
  558.  
  559.